home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / pakstuff.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  24.1 KB  |  1,189 lines
  1.  
  2. #include <stdio.h>
  3. #include <stdarg.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <windows.h>
  7. #include "io.h"
  8. #include "pakstuff.h"
  9. #include "unzip.h"
  10. //#include "cmdlib.h"
  11. #include "str.h"
  12.  
  13. int m_nPAKIndex;
  14. FILE* pakfile[16];
  15. struct PACKDirectory    pakdir;
  16. PACKDirPtr                pakdirptr = &pakdir;
  17. UInt16                    dirsize;
  18. boolean                    pakopen = false;
  19. int                        f_type;
  20. DIRECTORY                *paktextures = NULL;
  21. boolean                    HavePakColormap;
  22. UInt32                    PakColormapOffset;
  23. UInt32                    PakColormapSize;
  24. DIRECTORY                *dirhead = NULL;
  25. boolean g_bPK3 = false;
  26. char g_strBasePath[1024];
  27.  
  28. struct PK3FileInfo
  29. {
  30.   unzFile m_zFile;
  31.   char *m_pName;
  32.   unz_s m_zInfo;
  33.   long m_lSize;
  34.   ~PK3FileInfo()
  35.   {
  36.     delete []m_pName;
  37.   }
  38.   bool operator ==(const PK3FileInfo& rhs) const { return strcmp(m_pName, rhs.m_pName) == 0; }
  39. };
  40.  
  41. #define __PATHSEPERATOR   '/'
  42.  
  43. #define LOG_PAKFAIL
  44.  
  45. #ifdef LOG_PAKFAIL
  46.  
  47. class LogFile
  48. {
  49. public:
  50.   FILE *m_pFile;
  51.   LogFile(const char* pName)
  52.   {
  53.     m_pFile = fopen(pName, "w");
  54.   }
  55.   ~LogFile()
  56.   {
  57.     if (m_pFile)
  58.     {
  59.       fclose(m_pFile);
  60.     }
  61.   }
  62.   void Log(const char *pFormat, ...)
  63.   {
  64.     va_list arg_ptr;
  65.     va_start(arg_ptr, pFormat);
  66.     fprintf(m_pFile, pFormat, arg_ptr);
  67.     va_end(arg_ptr);
  68.   }
  69. };
  70.  
  71. LogFile g_LogFile("c:\\paklog.txt");
  72. #endif
  73.  
  74. template <class T> class StrPtr : public Str
  75. {
  76. protected:
  77.   T* m_pPtr;
  78.   StrPtr()
  79.   {
  80.     m_pPtr = NULL;
  81.   }
  82.  
  83.   StrPtr(const char *pStr, T *p) : Str(pStr)
  84.   {
  85.     m_pPtr = p;
  86.   }
  87.  
  88.   T* Ptr()
  89.   {
  90.     return m_pPtr;
  91.   }
  92.  
  93.   T& Ref()
  94.   {
  95.     return *m_pPtr;
  96.   }
  97.     
  98.  
  99. };
  100. // PtrList
  101. // a list of ptrs
  102. // 
  103. template <class T> class PtrList
  104. {
  105. protected:
  106.   T *m_pPtr;
  107.   PtrList *m_pNext;
  108.  
  109. public:
  110.  
  111.   PtrList()
  112.   {
  113.     m_pNext = NULL;
  114.     m_pPtr = NULL;
  115.   }
  116.  
  117.   PtrList(T *ip)
  118.   {
  119.     m_pNext = NULL;
  120.     m_pPtr = ip;
  121.   }
  122.  
  123.   ~PtrList()
  124.   {
  125.     delete m_pPtr;
  126.   }
  127.  
  128.   PtrList* Next()
  129.   {
  130.     return m_pNext;
  131.   }
  132.  
  133.   void Add(T *ip)
  134.   {
  135.     PtrList *pl = this;
  136.     while (pl && pl->m_pNext)
  137.     {
  138.       pl = pl->Next();
  139.     }
  140.     pl->m_pNext = new PtrList(ip);
  141.   }
  142.  
  143.   void Remove()
  144.   {
  145.     PtrList *p = m_pNext;
  146.     if (p)
  147.     {
  148.       while (p->m_pNext != this && p->m_pNext != NULL)
  149.       {
  150.         p = p->m_pNext;
  151.       }
  152.       if (p->m_pNext == this)
  153.       {
  154.         p->m_pNext = m_pNext;
  155.       }
  156.     }
  157.   }
  158.  
  159.   virtual PtrList* Find(T *ip)
  160.   {
  161.     PtrList *p = m_pNext;
  162.     while (p)
  163.     {
  164.       if (*p->m_pPtr == *ip)
  165.       {
  166.         return p;
  167.       }
  168.       p = p->m_pNext;
  169.     }
  170.     return NULL;
  171.   }
  172.  
  173.   // remove vp from the list
  174.   void Remove(T *ip)
  175.   {
  176.     PtrList *p = Find(ip);
  177.     if (p)
  178.     {
  179.       p->Remove();
  180.     }
  181.   }
  182.  
  183.   T* Ptr()
  184.   {
  185.     return m_pPtr;
  186.   }
  187.  
  188.   T& Ref()
  189.   {
  190.     return *m_pPtr;
  191.   }
  192.  
  193.   void RemoveAll()
  194.   {
  195.     PtrList *p = m_pNext;
  196.     while (p)
  197.     {
  198.       PtrList *p2 = p;
  199.       p = p->m_pNext;
  200.       delete p2;
  201.     }
  202.   }
  203. };
  204.  
  205.  
  206. typedef PtrList<unzFile> ZFileList;
  207. typedef PtrList<Str> StrList;
  208. typedef PtrList<PK3FileInfo> PK3List;
  209.  
  210.  
  211. StrList g_PK3TexturePaths;
  212. PK3List g_PK3Files;
  213. ZFileList g_zFiles;
  214. #define WORK_LEN 1024
  215. #define TEXTURE_PATH "textures"
  216. #define PATH_SEPERATORS "/\\:\0"
  217.  
  218.  
  219. char* __StrDup(char* pStr)
  220. { 
  221.   if (pStr)
  222.   {
  223.     return strcpy(new char[strlen(pStr)+1], pStr); 
  224.   }
  225.   return NULL;
  226. }
  227.  
  228. char* __StrDup(const char* pStr)
  229. { 
  230.   if (pStr)
  231.   {
  232.     return strcpy(new char[strlen(pStr)+1], pStr); 
  233.   }
  234.   return NULL;
  235. }
  236.  
  237. #define MEM_BLOCKSIZE 4096
  238. void* __qblockmalloc(size_t nSize)
  239. {
  240.     void *b;
  241.   // round up to threshold
  242.   int nAllocSize = nSize % MEM_BLOCKSIZE;
  243.   if ( nAllocSize > 0)
  244.   {
  245.     nSize += MEM_BLOCKSIZE - nAllocSize;
  246.   }
  247.     b = malloc(nSize + 1);
  248.     memset (b, 0, nSize);
  249.     return b;
  250. }
  251.  
  252. void* __qmalloc (size_t nSize)
  253. {
  254.     void *b;
  255.     b = malloc(nSize + 1);
  256.     memset (b, 0, nSize);
  257.     return b;
  258. }
  259.  
  260.  
  261. /*
  262. ====================
  263. Extract file parts
  264. ====================
  265. */
  266. void __ExtractFilePath (const char *path, char *dest)
  267. {
  268.     const char *src;
  269.  
  270.     src = path + strlen(path) - 1;
  271.  
  272. //
  273. // back up until a \ or the start
  274. //
  275.     while (src != path && *(src-1) != __PATHSEPERATOR)
  276.         src--;
  277.  
  278.     memcpy (dest, path, src-path);
  279.     dest[src-path] = 0;
  280. }
  281.  
  282. void __ExtractFileName (const char *path, char *dest)
  283. {
  284.     const char *src;
  285.  
  286.     src = path + strlen(path) - 1;
  287.  
  288. //
  289. // back up until a \ or the start
  290. //
  291.     while (src != path && *(src-1) != '/' 
  292.          && *(src-1) != '\\' )
  293.         src--;
  294.  
  295.     while (*src)
  296.     {
  297.         *dest++ = *src++;
  298.     }
  299.     *dest = 0;
  300. }
  301.  
  302. void __ExtractFileBase (const char *path, char *dest)
  303. {
  304.     const char *src;
  305.  
  306.     src = path + strlen(path) - 1;
  307.  
  308. //
  309. // back up until a \ or the start
  310. //
  311.     while (src != path && *(src-1) != '/' 
  312.          && *(src-1) != '\\' )
  313.         src--;
  314.  
  315.     while (*src && *src != '.')
  316.     {
  317.         *dest++ = *src++;
  318.     }
  319.     *dest = 0;
  320. }
  321.  
  322. void __ExtractFileExtension (const char *path, char *dest)
  323. {
  324.     const char *src;
  325.  
  326.     src = path + strlen(path) - 1;
  327.  
  328. //
  329. // back up until a . or the start
  330. //
  331.     while (src != path && *(src-1) != '.')
  332.         src--;
  333.     if (src == path)
  334.     {
  335.         *dest = 0;    // no extension
  336.         return;
  337.     }
  338.  
  339.     strcpy (dest,src);
  340. }
  341.  
  342.  
  343. void __ConvertDOSToUnixName( char *dst, const char *src )
  344. {
  345.     while ( *src )
  346.     {
  347.         if ( *src == '\\' )
  348.             *dst = '/';
  349.         else
  350.             *dst = *src;
  351.         dst++; src++;
  352.     }
  353.     *dst = 0;
  354. }
  355.  
  356.  
  357.  
  358.  
  359.  
  360. void AddSlash(Str& str)
  361. {
  362.   int nLen = str.GetLength();
  363.   if (nLen > 0)
  364.   {
  365.     if (str[nLen-1] != '\\' && str[nLen-1] != '/')
  366.       str += '\\';
  367.   }
  368. }
  369.  
  370. void FindReplace(Str& strContents, const char* pTag, const char* pValue)
  371. {
  372.   if (strcmp(pTag, pValue) == 0)
  373.     return;
  374.   for (int nPos = strContents.Find(pTag); nPos >= 0; nPos = strContents.Find(pTag))
  375.   {
  376.     int nRightLen = strContents.GetLength() - strlen(pTag) - nPos;
  377.     Str strLeft(strContents.Left(nPos));
  378.     Str strRight(strContents.Right(nRightLen));
  379.     strLeft += pValue;
  380.     strLeft += strRight;
  381.     strContents = strLeft;
  382.   }
  383. }
  384.  
  385.  
  386.  
  387.  
  388.  
  389. void ProgError(char *errstr, ...)
  390. {
  391.   va_list args;
  392.  
  393.   va_start(args, errstr);
  394.   printf("\nProgram Error: *** ");
  395.   vprintf(errstr, args);
  396.   printf(" ***\n");
  397.   va_end(args);
  398.   exit(5);
  399. }
  400.  
  401. boolean ReadBytes(FILE *file, void *addr, UInt32 size)
  402. {
  403.   while (size > 0x8000)
  404.     {
  405.       if (fread(addr, 1, 0x8000, file) != 0x8000)
  406.     return false;
  407.       addr = (char *)addr + 0x8000;
  408.       size -= 0x8000;
  409.     }
  410.   if (fread(addr, 1, size, file) != size)
  411.     return false;
  412.   return true;
  413. }
  414. int ReadMagic(FILE *file)
  415. {
  416.   UInt8 buf[4];
  417.  
  418.   if (ReadBytes(file, buf, 4) == FALSE)
  419.     return FTYPE_ERROR;
  420.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "IWAD", 4))
  421.     return FTYPE_IWAD;
  422.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "PWAD", 4))
  423.     return FTYPE_PWAD;
  424.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "PACK", 4))
  425.     return FTYPE_PACK;
  426.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "WAD2", 4))
  427.     return FTYPE_WAD2;
  428.   if (buf[0] == 0x17 && buf[1] == 0 && buf[2] == 0 && buf[3] == 0)
  429.     return FTYPE_BSP;
  430.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "IDPO", 4))
  431.     return FTYPE_MODEL;
  432.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "IDSP", 4))
  433.     return FTYPE_SPRITE;
  434.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "RIFF", 4))
  435.     return FTYPE_WAV;
  436.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), ".snd", 4))
  437.     return FTYPE_AU;
  438.   if (buf[0] == 'P')
  439.     {
  440.       if (buf[1] == '1')
  441.     return FTYPE_PBM_ASC;
  442.       if (buf[1] == '2')
  443.     return FTYPE_PGM_ASC;
  444.       if (buf[1] == '3')
  445.     return FTYPE_PPM_ASC;
  446.       if (buf[1] == '4')
  447.     return FTYPE_PBM_RAW;
  448.       if (buf[1] == '5')
  449.     return FTYPE_PGM_RAW;
  450.       if (buf[1] == '6')
  451.     return FTYPE_PPM_RAW;
  452.     }
  453.   if (buf[0] == 'B' && buf[1] == 'M')
  454.     return FTYPE_BMP;
  455.   if (!strncmp(reinterpret_cast<const char*>(&buf[0]), "GIF8", 4))
  456.     return FTYPE_GIF;
  457.   if (buf[0] == 0x0a && buf[1] == 0x05 && buf[2] == 0x01 && buf[3] == 0x08)
  458.     return FTYPE_PCX;
  459.   return FTYPE_UNKNOWN;
  460. }
  461. FILE *OpenFileReadMagic(const char *filename, int *ftype_r)
  462. {
  463.   FILE *f;
  464.  
  465.   *ftype_r = FTYPE_ERROR;
  466.   if ((f = fopen(filename, "rb")) == NULL)
  467.     return NULL;
  468.   *ftype_r = ReadMagic(f);
  469.   if (*ftype_r == FTYPE_ERROR)
  470.     {
  471.       fclose(f);
  472.       return NULL;
  473.     }
  474.   return f;
  475. }
  476. boolean WriteBytes(FILE *file, void *addr, UInt32 size)
  477. {
  478.   while (size > 0x8000)
  479.     {
  480.       if (fwrite(addr, 1, 0x8000, file) != 0x8000)
  481.     return FALSE;
  482.       addr = (char *)addr + 0x8000;
  483.       size -= 0x8000;
  484.     }
  485.   if (fwrite(addr, 1, size, file) != size)
  486.     return FALSE;
  487.   return TRUE;
  488. }
  489. char *ConvertFilePath(char *filename)
  490. {
  491.   char *cp;
  492.   
  493.   if (filename == NULL)
  494.     ProgError("BUG: cannot convert a NULL pathname");
  495.   for (cp = filename; *cp; cp++)
  496.     if (*cp == '/' || *cp == '\\')
  497.       {
  498. #ifdef QEU_DOS
  499.     *cp = '\\';
  500. #else
  501.     *cp = '/';
  502. #endif
  503.       }
  504.   return filename;
  505. }
  506.  
  507. /*
  508.  * Read the PACK directory into memory.  The optional offset to the
  509.  * start of the PACK file is given in "offset".  The number of files in
  510.  * the directory is returned in *dirsize_r.
  511.  */
  512. PACKDirPtr ReadPACKDirectory(FILE *packfile, UInt32 offset, UInt16 *dirsize_r)
  513. {
  514.   PACKDirPtr dir;
  515.   UInt32     pos, size;
  516.   UInt16     max, i;
  517.  
  518.   *dirsize_r = 0;
  519.   if (packfile == NULL)
  520.     return NULL;
  521.   if ((fseek(packfile, offset, SEEK_SET) < 0)
  522.       || (ReadMagic(packfile) != FTYPE_PACK)
  523.       || (ReadInt32(packfile, &pos) == FALSE)
  524.       || (ReadInt32(packfile, &size) == FALSE)
  525.       || (size == 0L)
  526.       || (size / sizeof(struct PACKDirectory) > 65535L)
  527.       || (fseek(packfile, offset + pos, SEEK_SET) < 0))
  528.     return NULL;
  529.   dir = (PACKDirPtr)__qmalloc(size);
  530.   max = (UInt16)(size / sizeof(struct PACKDirectory));
  531.   for (i = 0; i < max; i++)
  532.     {
  533.       if (ReadBytes(packfile, &dir[i], sizeof(struct PACKDirectory)) == FALSE)
  534.     {
  535.       free(dir);
  536.       return NULL;
  537.     }
  538.       ConvertFilePath(dir[i].name);
  539.       dir[i].offset = SwapInt32(dir[i].offset);
  540.       dir[i].size = SwapInt32(dir[i].size);
  541.     }
  542.   *dirsize_r = max;
  543.   return dir;
  544. }
  545.  
  546. /*
  547.  * Print the contents of the PACK directory in "outf".
  548.  */
  549. void DumpPACKDirectory(FILE *outf, PACKDirPtr dir, UInt16 dirsize)
  550. {
  551.     UInt16 i;
  552.     UInt32 sum;
  553.     char   buf[57];
  554.  
  555.     if (outf == NULL || dir == NULL || dirsize == 0)
  556.         return;
  557.     fprintf(outf, "num    offset     size    file name\n");
  558.     fprintf(outf, "       (hex)      (dec)\n");
  559.     sum = 0L;
  560.     for (i = 0; i < dirsize; i++)
  561.     {
  562.         if(!strnicmp(dir[i].name, "textures", 8))
  563.         {
  564.           strncpy(buf, dir[i].name, 56);
  565.           buf[56] = '\0';
  566.           fprintf(outf, "%3u  0x%08lx  %6ld   %s\n",
  567.               i, dir[i].offset, dir[i].size, buf);
  568.           sum += dir[i].size;
  569.         }
  570.     }
  571.     fprintf(outf, "\nTotal size for %3u entries:  %7lu bytes.\n", dirsize, sum);
  572.     fprintf(outf, "Size of the PACK directory:  %7lu bytes.\n",
  573.         (UInt32)dirsize * (UInt32)sizeof(struct PACKDirectory));
  574.     fprintf(outf, "Total (header + data + dir): %7lu bytes.\n",
  575.         12L + sum + (UInt32)dirsize * (UInt32)sizeof(struct PACKDirectory));
  576. }
  577.  
  578. void ClearFileList(FILELIST **list)
  579. {
  580.     FILELIST    *temp;
  581.  
  582.     while(*list)
  583.     {
  584.         temp = *list;
  585.         *list = (*list)->next;
  586.         free(temp);
  587.     }
  588. }
  589.  
  590. void ClearDirList(DIRLIST **list)
  591. {
  592.     DIRLIST    *temp;
  593.  
  594.     while(*list)
  595.     {
  596.         temp = *list;
  597.         *list = (*list)->next;
  598.         free(temp);
  599.     }
  600. }
  601.  
  602. DIRECTORY *FindPakDir(DIRECTORY *dir, char *name)
  603. {
  604.     DIRECTORY    *currentPtr;
  605.  
  606.     for(currentPtr = dir; currentPtr; currentPtr = currentPtr->next)
  607.     {
  608.         if(!stricmp(name, currentPtr->name))
  609.         {
  610.             return currentPtr;
  611.         }
  612.     }
  613.     return NULL;
  614. }
  615.  
  616.  
  617. // LoadPK3FileList
  618. // ---------------
  619. //
  620. // This gets passed a file mask which we want to remove as 
  621. // we are only interested in the directory name and any given
  622. // extension. Only handles explicit filenames or *.something
  623. //
  624. boolean LoadPK3FileList(FILELIST **filelist, const char *pattern)
  625. {
  626.   char cSearch[WORK_LEN];
  627.     __ConvertDOSToUnixName( cSearch, pattern );
  628.   char cPath[WORK_LEN];
  629.   char cExt[WORK_LEN];
  630.   char cFile[WORK_LEN];
  631.   char cWork[WORK_LEN];
  632.   __ExtractFilePath(pattern, cPath);
  633.   __ExtractFileName(pattern, cFile);
  634.   __ExtractFileExtension(pattern, cExt);
  635.   const char *pCompare = (strnicmp(cFile, "*.", 2) == 0) ? cExt : cFile;
  636.   strcpy(cWork, cPath);
  637.   sprintf(cPath, "textures/%s", cWork);
  638.  
  639.   PK3List *p = g_PK3Files.Next();
  640.   while (p != NULL)
  641.   {
  642.     // qualify the path
  643.     PK3FileInfo *pKey = p->Ptr();
  644.     if (strstr(pKey->m_pName, cPath) && strstr(pKey->m_pName, pCompare))
  645.     {
  646.       __ExtractFileName(pKey->m_pName, cWork); 
  647.       AddToFileListAlphabetized(filelist, cWork, 0, 0, false);
  648.     }
  649.     p = p->Next();
  650.   }
  651.   return (*filelist) != NULL;
  652. }
  653.  
  654. boolean GetPackFileList(FILELIST **filelist, char *pattern)
  655. {
  656.     char                    *str1, *str2;
  657.     int                        i;
  658.     DIRECTORY                *dummy = paktextures;
  659.     FILELIST                *temp;
  660.  
  661.     if (!pakopen)
  662.         return false;
  663.  
  664.   if (g_bPK3)
  665.   {
  666.     return LoadPK3FileList(filelist, pattern);
  667.   }
  668.  
  669.     str1 = pattern;
  670.  
  671.     for(i = 0; pattern[i] != '\0'; i++)
  672.     {
  673.         if(pattern[i] == '\\')
  674.             pattern[i] = '/';
  675.     }
  676.  
  677.     while(strchr(str1, '/'))
  678.     {
  679.         str2 = strchr(str1, '/');
  680.         *str2++ = '\0';
  681.         dummy = FindPakDir(dummy, str1);
  682.         if(!dummy)
  683.             return false;
  684.         str1 = str2;
  685.     }
  686.     for(temp = dummy->files; temp; temp=temp->next)
  687.     {
  688.       AddToFileListAlphabetized(filelist, temp->filename, temp->offset, 0, false);
  689.     }
  690.     return true;
  691. }
  692.  
  693. boolean GetPackTextureDirs(DIRLIST **dirlist)
  694. {
  695.     UInt16                    i;
  696.     char                    buf[57];
  697.  
  698.     if (!pakopen)
  699.         return 1;
  700.  
  701.   if (g_bPK3)
  702.   {
  703.     StrList *pl = g_PK3TexturePaths.Next();
  704.     while (pl != NULL)
  705.     {
  706.       AddToDirListAlphabetized(dirlist, pl->Ref(), 0);
  707.       pl = pl->Next();
  708.     }
  709.     return true;
  710.   }
  711.  
  712.     for (i = 0; i < dirsize; i++)
  713.     {
  714.         if(!strnicmp(pakdirptr[i].name, "textures", 8))
  715.         {
  716.             strncpy(buf, &(pakdirptr[i].name[9]), 46);
  717.             if(strchr(buf, '\\'))
  718.               *strchr(buf, '\\') = '\0';
  719.             else if(strchr(buf, '/'))
  720.               *strchr(buf, '/') = '\0';
  721.             else
  722.               buf[56] = '\0';
  723.  
  724.             if(strchr(buf, '.'))
  725.                 continue;
  726.  
  727.             AddToDirListAlphabetized(dirlist, buf, 0);
  728.         }
  729.     }
  730.     return true;
  731. }
  732.  
  733. boolean AddToDirListAlphabetized(DIRLIST **list, char *dirname, int from)
  734. {
  735.     DIRLIST    *currentPtr, *previousPtr, *newPtr;
  736.  
  737.     strlwr(dirname);
  738.     for(currentPtr = *list; currentPtr; currentPtr = currentPtr->next)
  739.     {
  740.         if(!stricmp(dirname, currentPtr->dirname))
  741.         {
  742.             return false;
  743.         }
  744.     }
  745.     previousPtr = NULL;
  746.     currentPtr = *list;
  747.  
  748.     if((newPtr = (DIRLIST *)__qmalloc(sizeof(DIRLIST))) == NULL)
  749.         return false;
  750.  
  751.     strcpy(newPtr->dirname, dirname);
  752.     newPtr->from = from;
  753.  
  754.     while(currentPtr != NULL && stricmp(dirname, currentPtr->dirname) > 0)
  755.     {
  756.         previousPtr = currentPtr;
  757.         currentPtr = currentPtr->next;
  758.     } //End while
  759.     if(previousPtr == NULL)
  760.     {
  761.         newPtr->next = *list;
  762.         *list = newPtr;
  763.     } //End if
  764.     else
  765.     {
  766.         previousPtr->next = newPtr;
  767.         newPtr->next = currentPtr;
  768.     } //End else
  769.     return true;
  770. }
  771.  
  772. boolean AddToFileListAlphabetized(FILELIST **list, char *filename, UInt32 offset, UInt32 size, boolean dirs)
  773. {
  774.     FILELIST    *currentPtr, *previousPtr, *newPtr;
  775.  
  776.     for(currentPtr = *list; currentPtr; currentPtr = currentPtr->next)
  777.     {
  778.         if(!stricmp(filename, currentPtr->filename))
  779.         {
  780.             return false;
  781.         }
  782.     }
  783.     previousPtr = NULL;
  784.     currentPtr = *list;
  785.  
  786.     if((newPtr = (FILELIST *)__qmalloc(sizeof(FILELIST))) == NULL)
  787.         return false;
  788.  
  789.     strcpy(newPtr->filename, filename);
  790.     newPtr->offset = offset;
  791.     newPtr->size = size;
  792.  
  793.     while(currentPtr != NULL && stricmp(filename, currentPtr->filename) > 0)
  794.     {
  795.         previousPtr = currentPtr;
  796.         currentPtr = currentPtr->next;
  797.     } //End while
  798.     if(previousPtr == NULL)
  799.     {
  800.         newPtr->next = *list;
  801.         *list = newPtr;
  802.     } //End if
  803.     else
  804.     {
  805.         previousPtr->next = newPtr;
  806.         newPtr->next = currentPtr;
  807.     } //End else
  808.     return true;
  809. }
  810.  
  811. boolean PakLoadFile(const char *filename, void **bufferptr)
  812. {
  813.     FILELIST    *p = NULL;
  814.     DIRECTORY    *dummy;
  815.     void        *buffer;
  816.     char        *str1, *str2;
  817.  
  818.     if(!pakopen)
  819.         return false;
  820.  
  821.   Str str(filename);
  822.   __ConvertDOSToUnixName(str, str);
  823.  
  824.     dummy = paktextures;
  825.     str1 = str;
  826.  
  827.     while(strchr(str1, '/'))
  828.     {
  829.         str2 = strchr(str1, '/');
  830.         *str2++ = '\0';
  831.         dummy = FindPakDir(dummy, str1);
  832.         if(!dummy)
  833.             return false;
  834.         str1 = str2;
  835.     }
  836.  
  837.   // FIXME: add error handling routines
  838.     for(p = dummy->files; p; p = p->next)
  839.     {
  840.         if(!stricmp(str1, p->filename))
  841.         {
  842.             if (fseek(pakfile[m_nPAKIndex], p->offset, SEEK_SET) < 0)
  843.             {
  844.                 //Sys_Printf("Unexpected EOF in pakfile\n");
  845.                 return false;
  846.             }
  847.             if((buffer = __qmalloc(p->size+5)) == NULL)
  848.                 //Error("Could not allocate memory");
  849.     
  850.             if(fread(buffer, 1, p->size, pakfile[m_nPAKIndex]) != p->size)
  851.             {
  852.                 //Sys_Printf("Error reading %s from pak\n", str1);
  853.                 free(buffer);
  854.                 return false;
  855.             }
  856.             *bufferptr = buffer;
  857.             return true;
  858.         }
  859.     }
  860.     return false;
  861. }
  862.  
  863. int PakLoadAnyFile(const char *filename, void **bufferptr)
  864. {
  865.   char cWork[WORK_LEN];
  866.   if (g_bPK3)
  867.   {
  868.     PK3FileInfo *pInfo;
  869.     Str strKey;
  870.     // need to lookup the file without the base/texture path on it
  871.     Str strBase(g_strBasePath);
  872.     AddSlash(strBase);
  873.     __ConvertDOSToUnixName(cWork, strBase);
  874.     Str strFile(filename);
  875.     __ConvertDOSToUnixName(strFile, strFile);
  876.     strFile.MakeLower();
  877.     strlwr(cWork);
  878.     FindReplace(strFile, cWork, "");
  879.  
  880.     PK3FileInfo infoFind;
  881.     infoFind.m_pName = __StrDup(strFile.GetBuffer());
  882.     PK3List *pList = g_PK3Files.Find(&infoFind);
  883.     if (pList)
  884.     {
  885.       pInfo = pList->Ptr();
  886.       memcpy(pInfo->m_zFile, &pInfo->m_zInfo, sizeof(unz_s));
  887.       if (unzOpenCurrentFile(pInfo->m_zFile) == UNZ_OK)
  888.       {
  889.         void *buffer = __qblockmalloc(pInfo->m_lSize+1);
  890.         int n = unzReadCurrentFile(pInfo->m_zFile , buffer, pInfo->m_lSize);
  891.         *bufferptr = buffer;
  892.         unzCloseCurrentFile(pInfo->m_zFile);
  893.         return n;
  894.       }
  895.     }
  896. #ifdef LOG_PAKFAIL
  897.     sprintf(cWork, "PAK failed on %s\n", filename);
  898.     g_LogFile.Log(cWork);
  899. #endif
  900.     return -1;
  901.   }
  902.  
  903.     for (int i = 0; i < dirsize; i++)
  904.     {
  905.         if(!stricmp(filename, pakdirptr[i].name))
  906.         {
  907.             if (fseek(pakfile[m_nPAKIndex], pakdirptr[i].offset, SEEK_SET) >= 0)
  908.       {
  909.           void *buffer = __qmalloc (pakdirptr[i].size+1);
  910.           ((char *)buffer)[pakdirptr[i].size] = 0;
  911.               if (fread(buffer, 1, pakdirptr[i].size, pakfile[m_nPAKIndex]) == pakdirptr[i].size)
  912.         {
  913.           *bufferptr = buffer;
  914.           return pakdirptr[i].size;
  915.         }
  916.       }
  917.         }
  918.     }
  919. #ifdef LOG_PAKFAIL
  920.     sprintf(cWork, "PAK failed on %s\n", filename);
  921.     g_LogFile.Log(cWork);
  922. #endif
  923.   return -1;
  924. }
  925.  
  926.  
  927.  
  928. DIRECTORY *AddPakDir(DIRECTORY **dir, char *name)
  929. {
  930.     DIRECTORY    *currentPtr, *previousPtr, *newPtr;
  931.  
  932.     for(currentPtr = *dir; currentPtr; currentPtr = currentPtr->next)
  933.     {
  934.         if(!stricmp(name, currentPtr->name))
  935.         {
  936.             return currentPtr;
  937.         }
  938.     }
  939.     previousPtr = NULL;
  940.     currentPtr = *dir;
  941.  
  942.     if((newPtr = (DIRECTORY *)__qmalloc(sizeof(DIRECTORY))) == NULL)
  943.         return NULL;
  944.  
  945.     strcpy(newPtr->name, name);
  946.     newPtr->files = NULL;
  947.  
  948.     while(currentPtr != NULL && stricmp(name, currentPtr->name) > 0)
  949.     {
  950.         previousPtr = currentPtr;
  951.         currentPtr = currentPtr->next;
  952.     }
  953.     if(previousPtr == NULL)
  954.     {
  955.         newPtr->next = *dir;
  956.         *dir = newPtr;
  957.     }
  958.     else
  959.     {
  960.         previousPtr->next = newPtr;
  961.         newPtr->next = currentPtr;
  962.     }
  963.     return newPtr;
  964. }
  965.  
  966.  
  967. // OpenPK3
  968. // -------
  969. // Opens a PK3 ( or zip ) file and creates a list of filenames
  970. // and zip info structures
  971. // 
  972. boolean OpenPK3(const char *filename)
  973. {
  974.   char cFilename[WORK_LEN];
  975.   char cName[WORK_LEN];
  976.   char cWork[WORK_LEN];
  977.   unz_file_info zInfo;
  978.   unzFile *zFile = new unzFile(unzOpen(filename));
  979.   g_zFiles.Add(zFile);
  980.   if (zFile != NULL)
  981.   {
  982.     int nStatus = unzGoToFirstFile(*zFile);
  983.     while (nStatus == UNZ_OK)
  984.     {
  985.       cFilename[0] = '\0';
  986.       unzGetCurrentFileInfo(*zFile, &zInfo, cFilename, WORK_LEN, NULL, 0, NULL, 0);
  987.       strlwr(cFilename);
  988.         __ConvertDOSToUnixName( cWork, cFilename);
  989.       if (strstr(cWork, ".") != NULL)
  990.       {
  991.         PK3FileInfo *pInfo = new PK3FileInfo();
  992.         pInfo->m_pName = __StrDup(cWork);
  993.         memcpy(&pInfo->m_zInfo, (unz_s*)*zFile, sizeof(unz_s));
  994.         pInfo->m_lSize = zInfo.uncompressed_size;
  995.         pInfo->m_zFile = *zFile;
  996.         g_PK3Files.Add(pInfo);
  997.       }
  998.       char *p = strstr(cFilename, TEXTURE_PATH);
  999.       if (p != NULL)
  1000.       {
  1001.         // FIXME: path differences per os ?
  1002.         // catch solo directory entry
  1003.         if (strlen(p) > strlen(TEXTURE_PATH) + 1)
  1004.         {
  1005.           // skip textures + path seperator
  1006.           p += strlen(TEXTURE_PATH) + 1;
  1007.           int nEnd = strcspn(p, PATH_SEPERATORS);
  1008.           strncpy(cName, p, nEnd);
  1009.           cName[nEnd] = '\0';
  1010.  
  1011.           boolean bFound = false;
  1012.           StrList *pl = g_PK3TexturePaths.Next();
  1013.           while (pl != NULL)
  1014.           {
  1015.             if (strcmpi(pl->Ref(), cName) == 0)
  1016.             {
  1017.               // already have this, continue
  1018.               bFound = true;
  1019.               break;
  1020.             }
  1021.             pl = pl->Next();
  1022.           }
  1023.           if (!bFound)
  1024.           {
  1025.             g_PK3TexturePaths.Add(new Str(cName));
  1026.           }
  1027.         }
  1028.       }
  1029.       nStatus = unzGoToNextFile(*zFile);
  1030.     }
  1031.   }
  1032.   return (zFile != NULL);
  1033. }
  1034.  
  1035. void closePK3(unzFile zf)
  1036. {
  1037.   unzClose(zf);
  1038. }
  1039.  
  1040. void OpenPakFile(const char *filename)
  1041. {
  1042.     int            i;
  1043.     char        *str1, *str2;
  1044.     DIRECTORY    *dummy;
  1045.  
  1046.     if(!pakopen)
  1047.         paktextures = NULL;
  1048.  
  1049.     HavePakColormap = false;
  1050.  
  1051.   Str strTest(filename);
  1052.   strTest.MakeLower();
  1053.   if (strTest.Find("pk3") >= 0 || strTest.Find("zip") >= 0)
  1054.   {
  1055.     pakopen = g_bPK3 = OpenPK3(filename);
  1056.     return;
  1057.   }
  1058.  
  1059.  
  1060.     if((pakfile[m_nPAKIndex] = OpenFileReadMagic(filename, &f_type)) == NULL)
  1061.     {
  1062.     //FIXME: error routine
  1063.         //Sys_Printf("ERROR: Could not open %s", filename);
  1064.         return;
  1065.     }
  1066.     if(f_type != FTYPE_PACK)
  1067.     {
  1068.         //Sys_Printf("ERROR: %s is not a valid pack file", filename);
  1069.         if(f_type != FTYPE_ERROR)
  1070.             fclose(pakfile[m_nPAKIndex]);
  1071.         return;
  1072.     }
  1073.     pakdirptr = ReadPACKDirectory(pakfile[m_nPAKIndex], 0, &dirsize);
  1074.     if (pakdirptr == NULL)
  1075.     {
  1076.         //Sys_Printf("ERROR: Could not read pack directory", filename);
  1077.         fclose(pakfile[m_nPAKIndex]);
  1078.         return;
  1079.     }
  1080.     if (dirsize == 0)
  1081.     {
  1082.         fclose(pakfile[m_nPAKIndex]);
  1083.         return;
  1084.     }
  1085.     for (i = 0; i < dirsize; i++)
  1086.     {
  1087.         if(!strnicmp("textures/", pakdirptr[i].name, 9))
  1088.         {
  1089.             dummy = paktextures;
  1090.             str1 = pakdirptr[i].name+9;
  1091.             while(strchr(str1, '/'))
  1092.             {
  1093.                 str2 = strchr(str1, '/');
  1094.                 *str2++ = '\0';
  1095.                     dummy = AddPakDir(dummy==paktextures?&paktextures:&dummy, str1);
  1096.                 str1 = str2;
  1097.             }
  1098.  
  1099.             AddToFileListAlphabetized(&(dummy->files), str1, pakdirptr[i].offset, pakdirptr[i].size, true);
  1100.         }
  1101.         else if(!strnicmp("pics/colormap.pcx", pakdirptr[i].name, 17))
  1102.         {
  1103.             HavePakColormap = true;
  1104.             PakColormapOffset = pakdirptr[i].offset;
  1105.             PakColormapSize = pakdirptr[i].size;
  1106.         }
  1107.     }
  1108.     pakopen = true;
  1109.  
  1110. }
  1111.  
  1112. void ClearPaKDir(DIRECTORY **dir)
  1113. {
  1114.     DIRECTORY    *d1 = *dir, *d2;
  1115.  
  1116.     while(d1)
  1117.     {
  1118.         ClearFileList(&(d1->files));
  1119.         d2 = d1;
  1120.         d1 = d1->next;
  1121.         free(d2);
  1122.     }
  1123. }
  1124.  
  1125. void CleanUpPakDirs()
  1126. {
  1127.   ClearPaKDir(&paktextures);
  1128.   paktextures = NULL;
  1129.   dirhead = NULL;
  1130.   g_PK3TexturePaths.RemoveAll();
  1131.   g_PK3Files.RemoveAll();
  1132. }
  1133.  
  1134. void ClosePakFile(void)
  1135. {
  1136.     if(pakopen)
  1137.   {
  1138.     if (g_bPK3)
  1139.     {
  1140.       ZFileList *p = g_zFiles.Next();
  1141.       while (p != NULL)
  1142.       {
  1143.         unzFile uz = p->Ref();
  1144.         closePK3(uz);
  1145.         p = p->Next();
  1146.       }
  1147.     }
  1148.     else
  1149.     {
  1150.       fclose(pakfile[m_nPAKIndex]);
  1151.     }
  1152.   }
  1153.     pakopen = false;
  1154.   CleanUpPakDirs();
  1155. }
  1156.  
  1157.  
  1158. void WINAPI InitPakFile(const char * pBasePath, const char *pName)
  1159. {
  1160.   m_nPAKIndex = 0;
  1161.   pakopen = false;
  1162.     paktextures = NULL;
  1163.   strcpy(g_strBasePath, pBasePath);
  1164.   if (pName == NULL)
  1165.   {
  1166.     char cWork[WORK_LEN];
  1167.       Str strPath(pBasePath);
  1168.     AddSlash(strPath);
  1169.       strPath += "*.pk3";
  1170.       bool bGo = true;
  1171.       struct _finddata_t fileinfo;
  1172.       int handle = _findfirst (strPath, &fileinfo);
  1173.       if (handle != -1)
  1174.       {
  1175.           do
  1176.           {
  1177.         sprintf(cWork, "%s\\%s", pBasePath, fileinfo.name);
  1178.         OpenPakFile(cWork);
  1179.           } while (_findnext( handle, &fileinfo ) != -1);
  1180.         _findclose (handle);
  1181.     }
  1182.     }
  1183.   else
  1184.   {
  1185.       OpenPakFile(pName);
  1186.   }
  1187. }
  1188.  
  1189.